Ky udhëzues ju tregon se si të rregulloni Gemma-n në një grup të dhënash të personalizuara tekst-në-sql duke përdorur Transformers Hugging Face dhe TRL . Do të mësoni:
- Çfarë është përshtatja e kuantizuar me gradë të ulët (QLoRA)
- Konfiguro mjedisin e zhvillimit
- Krijoni dhe përgatitni të dhënat e rregullimit të imët
- Rregulloni mirë Gemma duke përdorur TRL dhe SFTTrainer
- Testoni konkluzionet e modelit dhe gjeneroni pyetje SQL
Çfarë është përshtatja e kuantizuar me gradë të ulët (QLoRA)
Ky udhëzues demonstron përdorimin e Përshtatjes së Kuantizuar të Rangut të Ulët (QLoRA) , e cila u shfaq si një metodë popullore për të rregulluar në mënyrë efikase LLM-të pasi redukton kërkesat për burime llogaritëse duke ruajtur performancën e lartë. Në QloRA, modeli i paratrajnuar kuantizohet në 4-bit dhe peshat ngrihen. Më pas janë bashkangjitur shtresat e përshtatësve të trajnueshëm (LoRA) dhe trajnohen vetëm shtresat e përshtatësit. Më pas, peshat e përshtatësit mund të bashkohen me modelin bazë ose të mbahen si një përshtatës i veçantë.
Konfiguro mjedisin e zhvillimit
Hapi i parë është instalimi i Bibliotekave Hugging Face, duke përfshirë TRL, dhe grupet e të dhënave për të rregulluar mirë modelin e hapur, duke përfshirë teknika të ndryshme RLHF dhe shtrirje.
# Install Pytorch & other libraries
%pip install "torch>=2.4.0" tensorboard
# Install Gemma release branch from Hugging Face
%pip install "transformers>=4.51.3"
# Install Hugging Face libraries
%pip install --upgrade \
"datasets==3.3.2" \
"accelerate==1.4.0" \
"evaluate==0.4.3" \
"bitsandbytes==0.45.3" \
"trl==0.15.2" \
"peft==0.14.0" \
protobuf \
sentencepiece
# COMMENT IN: if you are running on a GPU that supports BF16 data type and flash attn, such as NVIDIA L4 or NVIDIA A100
#% pip install flash-attn
Shënim: Nëse jeni duke përdorur një GPU me arkitekturë Ampere (si NVIDIA L4) ose më të reja, mund të përdorni vëmendjen e Flash-it. Flash Attention është një metodë që shpejton ndjeshëm llogaritjet dhe redukton përdorimin e kujtesës nga kuadratik në linear në gjatësinë e sekuencës, duke çuar në përshpejtimin e trajnimit deri në 3x. Mësoni më shumë në FlashAttention .
Përpara se të filloni stërvitjen, duhet të siguroheni që i keni pranuar kushtet e përdorimit për Gemma. Ju mund ta pranoni licencën për Hugging Face duke klikuar në butonin "Pranoj dhe hyni në depo" në faqen e modelit në: http://huggingface.co/google/gemma-3-1b-pt
Pasi të keni pranuar licencën, ju nevojitet një shenjë e vlefshme Hugging Face për të hyrë në model. Nëse jeni duke vrapuar brenda një Google Colab, mund të përdorni në mënyrë të sigurt Token tuaj Hugging Face duke përdorur sekretet e Colab, përndryshe ju mund ta vendosni tokenin si direkt në metodën login . Sigurohuni që token juaj të ketë gjithashtu akses shkrimi, pasi e shtyni modelin tuaj në Hub gjatë trajnimit.
from google.colab import userdata
from huggingface_hub import login
# Login into Hugging Face Hub
hf_token = userdata.get('HF_TOKEN') # If you are running inside a Google Colab
login(hf_token)
Krijoni dhe përgatitni të dhënat e rregullimit të imët
Kur rregulloni mirë LLM-të, është e rëndësishme të dini rastin tuaj të përdorimit dhe detyrën që dëshironi të zgjidhni. Kjo ju ndihmon të krijoni një grup të dhënash për të rregulluar mirë modelin tuaj. Nëse nuk e keni përcaktuar ende rastin tuaj të përdorimit, mund të dëshironi të ktheheni në tabelën e vizatimit.
Si shembull, ky udhëzues fokusohet në rastin e mëposhtëm të përdorimit:
- Rregulloni një gjuhë natyrale me modelin SQL për integrim të qetë në një mjet analize të të dhënave. Objektivi është të reduktohet ndjeshëm koha dhe ekspertiza e kërkuar për gjenerimin e pyetjeve SQL, duke u mundësuar edhe përdoruesve jo teknikë të nxjerrin njohuri domethënëse nga të dhënat.
Text-to-SQL mund të jetë një rast i mirë përdorimi për rregullimin e saktë të LLM-ve, pasi është një detyrë komplekse që kërkon shumë njohuri (të brendshme) për të dhënat dhe gjuhën SQL.
Pasi të keni përcaktuar se rregullimi i imët është zgjidhja e duhur, ju duhet një grup të dhënash për të rregulluar mirë. Të dhënat duhet të jenë një grup i larmishëm demonstrimesh të detyrës(ave) që dëshironi të zgjidhni. Ka disa mënyra për të krijuar një grup të dhënash të tillë, duke përfshirë:
- Përdorimi i grupeve ekzistuese të të dhënave me burim të hapur, siç është Spider
- Përdorimi i grupeve të të dhënave sintetike të krijuara nga LLM, si Alpaca
- Përdorimi i grupeve të të dhënave të krijuara nga njerëzit, si Dolly .
- Duke përdorur një kombinim të metodave, të tilla si Orca
Secila prej metodave ka avantazhet dhe disavantazhet e veta dhe varet nga buxheti, koha dhe kërkesat e cilësisë. Për shembull, përdorimi i një grupi të dhënash ekzistuese është më i lehtë, por mund të mos jetë i përshtatur për rastin tuaj specifik të përdorimit, ndërsa përdorimi i ekspertëve të domenit mund të jetë më i sakti, por mund të marrë kohë dhe i kushtueshëm. Është gjithashtu e mundur të kombinohen disa metoda për të krijuar një grup të dhënash udhëzimi, siç tregohet në Orca: Mësimi Progresiv nga Gjurmët e Shpjegimit Kompleks të GPT-4.
Ky udhëzues përdor një grup të dhënash tashmë ekzistuese ( philschmid/gretel-synthetic-text-to-sql ), një grup të dhënash sintetike me cilësi të lartë Text-to-SQL duke përfshirë udhëzimet e gjuhës natyrore, përkufizimet e skemave, arsyetimin dhe pyetjen përkatëse SQL.
Hugging Face TRL mbështet shabllonin automatik të formateve të të dhënave të bisedave. Kjo do të thotë që ju duhet vetëm të konvertoni të dhënat tuaja në objektet e duhura json, dhe trl kujdeset për modelimin dhe vendosjen e tij në formatin e duhur.
{"messages": [{"role": "system", "content": "You are..."}, {"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}
{"messages": [{"role": "system", "content": "You are..."}, {"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}
{"messages": [{"role": "system", "content": "You are..."}, {"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]}
Philschmid/gretel-sinthetic-text-to-sql përmban mbi 100 mijë mostra. Për ta mbajtur udhëzuesin të vogël, ai zvogëlohet për të përdorur vetëm 10,000 mostra.
Tani mund të përdorni bibliotekën e grupeve të të dhënave Hugging Face për të ngarkuar grupin e të dhënave dhe për të krijuar një shabllon të shpejtë për të kombinuar udhëzimet e gjuhës natyrore, përkufizimin e skemës dhe për të shtuar një mesazh sistemi për asistentin tuaj.
from datasets import load_dataset
# System message for the assistant
system_message = """You are a text to SQL query translator. Users will ask you questions in English and you will generate a SQL query based on the provided SCHEMA."""
# User prompt that combines the user query and the schema
user_prompt = """Given the <USER_QUERY> and the <SCHEMA>, generate the corresponding SQL command to retrieve the desired data, considering the query's syntax, semantics, and schema constraints.
<SCHEMA>
{context}
</SCHEMA>
<USER_QUERY>
{question}
</USER_QUERY>
"""
def create_conversation(sample):
return {
"messages": [
# {"role": "system", "content": system_message},
{"role": "user", "content": user_prompt.format(question=sample["sql_prompt"], context=sample["sql_context"])},
{"role": "assistant", "content": sample["sql"]}
]
}
# Load dataset from the hub
dataset = load_dataset("philschmid/gretel-synthetic-text-to-sql", split="train")
dataset = dataset.shuffle().select(range(12500))
# Convert dataset to OAI messages
dataset = dataset.map(create_conversation, remove_columns=dataset.features,batched=False)
# split dataset into 10,000 training samples and 2,500 test samples
dataset = dataset.train_test_split(test_size=2500/12500)
# Print formatted user prompt
print(dataset["train"][345]["messages"][1]["content"])
Rregulloni mirë Gemma duke përdorur TRL dhe SFTTrainer
Tani jeni gati të rregulloni modelin tuaj. Hugging Face TRL SFTTrainer e bën të thjeshtë mbikëqyrjen e rregullimit të saktë të LLM-ve të hapura. SFTTrainer është një nënklasë e Trainer nga biblioteka transformers dhe mbështet të gjitha të njëjtat veçori, duke përfshirë regjistrimin, vlerësimin dhe pikën e kontrollit, por shton veçori shtesë të cilësisë së jetës, duke përfshirë:
- Formatimi i grupit të të dhënave, duke përfshirë formatet bisedore dhe udhëzuese
- Trajnimi vetëm për përfundimet, duke injoruar kërkesat
- Paketimi i të dhënave për trajnim më efikas
- Mbështetje për rregullimin e saktë të parametrave (PEFT) duke përfshirë QloRA
- Përgatitja e modelit dhe shënuesit për rregullimin e mirë të bisedës (si p.sh. shtimi i shenjave speciale)
Kodi i mëposhtëm ngarkon modelin dhe simbolin Gemma nga Hugging Face dhe inicializon konfigurimin e kuantizimit.
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, AutoModelForImageTextToText, BitsAndBytesConfig
# Hugging Face model id
model_id = "google/gemma-3-1b-pt" # or `google/gemma-3-4b-pt`, `google/gemma-3-12b-pt`, `google/gemma-3-27b-pt`
# Select model class based on id
if model_id == "google/gemma-3-1b-pt":
model_class = AutoModelForCausalLM
else:
model_class = AutoModelForImageTextToText
# Check if GPU benefits from bfloat16
if torch.cuda.get_device_capability()[0] >= 8:
torch_dtype = torch.bfloat16
else:
torch_dtype = torch.float16
# Define model init arguments
model_kwargs = dict(
attn_implementation="eager", # Use "flash_attention_2" when running on Ampere or newer GPU
torch_dtype=torch_dtype, # What torch dtype to use, defaults to auto
device_map="auto", # Let torch decide how to load the model
)
# BitsAndBytesConfig: Enables 4-bit quantization to reduce model size/memory usage
model_kwargs["quantization_config"] = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_use_double_quant=True,
bnb_4bit_quant_type='nf4',
bnb_4bit_compute_dtype=model_kwargs['torch_dtype'],
bnb_4bit_quant_storage=model_kwargs['torch_dtype'],
)
# Load model and tokenizer
model = model_class.from_pretrained(model_id, **model_kwargs)
tokenizer = AutoTokenizer.from_pretrained("google/gemma-3-1b-it") # Load the Instruction Tokenizer to use the official Gemma template
SFTTrainer mbështet një integrim vendas me peft , gjë që e bën të thjeshtë sintonizimin me efikasitet të LLM-ve duke përdorur QLoRA. Ju duhet vetëm të krijoni një LoraConfig dhe t'ia jepni atë trajnerit.
from peft import LoraConfig
peft_config = LoraConfig(
lora_alpha=16,
lora_dropout=0.05,
r=16,
bias="none",
target_modules="all-linear",
task_type="CAUSAL_LM",
modules_to_save=["lm_head", "embed_tokens"] # make sure to save the lm_head and embed_tokens as you train the special tokens
)
Përpara se të filloni stërvitjen tuaj, duhet të përcaktoni hiperparametrin që dëshironi të përdorni në një shembull SFTConfig .
from trl import SFTConfig
args = SFTConfig(
output_dir="gemma-text-to-sql", # directory to save and repository id
max_seq_length=512, # max sequence length for model and packing of the dataset
packing=True, # Groups multiple samples in the dataset into a single sequence
num_train_epochs=3, # number of training epochs
per_device_train_batch_size=1, # batch size per device during training
gradient_accumulation_steps=4, # number of steps before performing a backward/update pass
gradient_checkpointing=True, # use gradient checkpointing to save memory
optim="adamw_torch_fused", # use fused adamw optimizer
logging_steps=10, # log every 10 steps
save_strategy="epoch", # save checkpoint every epoch
learning_rate=2e-4, # learning rate, based on QLoRA paper
fp16=True if torch_dtype == torch.float16 else False, # use float16 precision
bf16=True if torch_dtype == torch.bfloat16 else False, # use bfloat16 precision
max_grad_norm=0.3, # max gradient norm based on QLoRA paper
warmup_ratio=0.03, # warmup ratio based on QLoRA paper
lr_scheduler_type="constant", # use constant learning rate scheduler
push_to_hub=True, # push model to hub
report_to="tensorboard", # report metrics to tensorboard
dataset_kwargs={
"add_special_tokens": False, # We template with special tokens
"append_concat_token": True, # Add EOS token as separator token between examples
}
)
Tani keni çdo bllok ndërtimi që ju nevojitet për të krijuar SFTTrainer tuaj për të filluar trajnimin e modelit tuaj.
from trl import SFTTrainer
# Create Trainer object
trainer = SFTTrainer(
model=model,
args=args,
train_dataset=dataset["train"],
peft_config=peft_config,
processing_class=tokenizer
)
Filloni stërvitjen duke thirrur metodën train() .
# Start training, the model will be automatically saved to the Hub and the output directory
trainer.train()
# Save the final model again to the Hugging Face Hub
trainer.save_model()
Përpara se të testoni modelin tuaj, sigurohuni që të lironi memorien.
# free the memory again
del model
del trainer
torch.cuda.empty_cache()
Kur përdorni QLoRA, ju trajnoni vetëm adaptorët dhe jo modelin e plotë. Kjo do të thotë kur ruani modelin gjatë stërvitjes, kurseni vetëm peshat e përshtatësit dhe jo modelin e plotë. Nëse dëshironi të ruani modelin e plotë, gjë që e bën më të lehtë përdorimin me grupe shërbyese si vLLM ose TGI, mund të bashkoni peshat e përshtatësit në peshat e modelit duke përdorur metodën merge_and_unload dhe më pas ta ruani modelin me metodën save_pretrained . Kjo ruan një model të paracaktuar, i cili mund të përdoret për përfundime.
from peft import PeftModel
# Load Model base model
model = model_class.from_pretrained(model_id, low_cpu_mem_usage=True)
# Merge LoRA and base model and save
peft_model = PeftModel.from_pretrained(model, args.output_dir)
merged_model = peft_model.merge_and_unload()
merged_model.save_pretrained("merged_model", safe_serialization=True, max_shard_size="2GB")
processor = AutoTokenizer.from_pretrained(args.output_dir)
processor.save_pretrained("merged_model")
Testoni konkluzionet e modelit dhe gjeneroni pyetje SQL
Pas përfundimit të trajnimit, do të dëshironi të vlerësoni dhe testoni modelin tuaj. Ju mund të ngarkoni mostra të ndryshme nga grupi i të dhënave testuese dhe të vlerësoni modelin në ato mostra.
import torch
from transformers import pipeline
model_id = "gemma-text-to-sql"
# Load Model with PEFT adapter
model = model_class.from_pretrained(
model_id,
device_map="auto",
torch_dtype=torch_dtype,
attn_implementation="eager",
)
tokenizer = AutoTokenizer.from_pretrained(model_id)
Le të ngarkojmë një mostër të rastësishme nga grupi i të dhënave testuese dhe të gjenerojmë një komandë SQL.
from random import randint
import re
# Load the model and tokenizer into the pipeline
pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)
# Load a random sample from the test dataset
rand_idx = randint(0, len(dataset["test"]))
test_sample = dataset["test"][rand_idx]
# Convert as test example into a prompt with the Gemma template
stop_token_ids = [tokenizer.eos_token_id, tokenizer.convert_tokens_to_ids("<end_of_turn>")]
prompt = pipe.tokenizer.apply_chat_template(test_sample["messages"][:2], tokenize=False, add_generation_prompt=True)
# Generate our SQL query.
outputs = pipe(prompt, max_new_tokens=256, do_sample=False, temperature=0.1, top_k=50, top_p=0.1, eos_token_id=stop_token_ids, disable_compile=True)
# Extract the user query and original answer
print(f"Context:\n", re.search(r'<SCHEMA>\n(.*?)\n</SCHEMA>', test_sample['messages'][0]['content'], re.DOTALL).group(1).strip())
print(f"Query:\n", re.search(r'<USER_QUERY>\n(.*?)\n</USER_QUERY>', test_sample['messages'][0]['content'], re.DOTALL).group(1).strip())
print(f"Original Answer:\n{test_sample['messages'][1]['content']}")
print(f"Generated Answer:\n{outputs[0]['generated_text'][len(prompt):].strip()}")
Përmbledhja dhe hapat e mëtejshëm
Ky tutorial trajtoi se si të rregulloni një model Gemma duke përdorur TRL dhe QLoRA. Shikoni dokumentet e mëposhtme në vijim:
- Mësoni se si të gjeneroni tekst me një model Gemma .
- Mësoni se si të rregulloni Gemma për detyrat e shikimit duke përdorur Transformatorët Hugging Face .
- Mësoni se si të kryeni akordim dhe konkluzion të shpërndarë në një model Gemma .
- Mësoni se si të përdorni modelet e hapura Gemma me Vertex AI .
- Mësoni se si të rregulloni Gemma duke përdorur KerasNLP dhe vendoseni në Vertex AI .